//Cambiar Blob
//http://blog.tecnopcx.com/archives/467/guardar-imagen-en-mysql-desde-java
package Model;

import DTO.Administrador;
import DTO.Antecedente_Personal_NOPatalogicos;
import DTO.Antecedente_Personal_Patalogicos;
import DTO.Antecedente_QT;
import DTO.AntecedentesGerico_obstetricos;
import DTO.Examen_Fisico;
import DTO.Ficha_Clinica;
import DTO.Heredo_Familiares;
import DTO.Paciente;
import DTO.Padecimiento_Actual;
import DTO.Receta;
import DTO.Recomendacion;
import java.awt.Image;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletResponse;
import javax.sql.rowset.serial.SerialBlob;
import javax.swing.ImageIcon;
import java.util.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.HashSet;

public class conexionBD {

    
    private String user;
    private String password;
    private String db;
    static private int id_administrador;
    private Connection conn = null;
    private Statement stm;
    private ResultSet rs;
    private SimpleDateFormat patron;
    Blob Directorio_1;
    FileInputStream file;
    File fi;
    private Manager mListas = new Manager();

    public conexionBD(String user, String pass, String nameDB) {
        this.user = user;
        this.password = pass;
        this.db = nameDB;
    }

    public void conectar() {
        try {
            DriverManager.registerDriver(new org.gjt.mm.mysql.Driver());
            conn = DriverManager.getConnection("jdbc:mysql://localhost/" + db + "?user=" + user + "&password=" + password);
            stm = conn.createStatement();
            System.out.println("Conexion exitosa");
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
            System.out.println("Error en base de datos");
        }
    }

    public void desconectar() {
        try {
            conn.close();
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public boolean validar_usuario(Administrador admin) throws SQLException {
        conectar();
        rs = stm.executeQuery("select * from Administrador "
                + "where correo = '" + admin.getCorreo() + "' and contrasenia = '" + admin.getContrasenia() + "';");
        rs.next();
        if (rs.getString("correo").equals(admin.getCorreo().trim())
                && rs.getString("contrasenia").equals(admin.getContrasenia().trim())) {
            admin.setNombre(rs.getString("nombre"));
            admin.setId_Administrador(rs.getInt("id_Administrador"));
           conexionBD.id_administrador = rs.getInt("id_Administrador");
          // System.out.println(this.id_administrador+" EDU");
            desconectar();
            return true;
        } else {
            return false;
        }

    }

    public void insertarAdministrador(Administrador ad) {
        conectar();
        String query = "INSERT INTO Administrador(nombre,correo, contrasenia) VALUES ('" + ad.getNombre() + "','" + ad.getCorreo() + "','" + ad.getContrasenia() + "')";
        try {
            stm.execute(query);
        } catch (Exception ex) {
            System.out.println(ex.getMessage());
        }
        desconectar();
    }

    public void actualizarAdmnistrador(int id_Adm, String camNomb) {
        conectar();
        try {
            stm.execute("UPDATE ADMINISTRADOR SET nombre='" + camNomb + "' WHERE id_Administrador=" + id_Adm);
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
    }

    public void borrarAdministrador(int id_Admin) {
        conectar();
        try {
            stm.execute("DELETE FROM ADMINISTRADOR WHERE id_Administrador=" + id_Admin);
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
    }

    //Insertar los datos de un nuevo paciente
    public boolean insertarPaciente(Paciente p) {
        boolean exitos = false;
        int registrosActualizados;
        try {
            conectar();
            PreparedStatement stt = conn.prepareStatement("INSERT INTO Paciente(idPaciente,nombre,primerApellido ,segundoApellido,fechaNacimiento ,direccion,telefono,ocupacion,correo,genero,foto,mimeFoto) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
            stt.clearParameters();

            ArrayList<Object> campos = p.toArray();


            stt.setInt(1, (Integer) campos.get(0));        // id paciente : String
            stt.setString(2, campos.get(1).toString());      // nombre : String
            stt.setString(3, campos.get(2).toString());      // primerA : String
            stt.setString(4, campos.get(3).toString());      // segundoA : String
            stt.setString(5, campos.get(4).toString());      // Fecha Nacimiento : String
            stt.setString(6, campos.get(5).toString());      // direccion : string
            stt.setString(7, campos.get(6).toString());      // telefono
            stt.setString(8, campos.get(7).toString());      // ocupacion 
            stt.setString(9, campos.get(8).toString());      // correo
            stt.setString(10, campos.get(9).toString());      // genero
            stt.setBlob(11, (Blob) getDirectorio_1());           // blob foto
            stt.setString(12, campos.get(11).toString());      // mimeFoto

            registrosActualizados = stt.executeUpdate();
            exitos = registrosActualizados == 1;
            stm.close();

        } catch (Exception e) {
            e.printStackTrace(System.err);
        } finally {
            desconectar();
        }
        return exitos;
    }

    //Insertar los datos de un nuevo paciente sin la imagen 
    public boolean insertarPac(Paciente p) {
        boolean exitos = false;
        conectar();
        String query = "INSERT INTO Paciente(idPaciente,nombre,primerApellido ,segundoApellido,fechaNacimiento ,direccion,telefono,ocupacion,correo,genero) VALUES "
                + "(" + p.getId_Paciente() + ",'" + p.getNombre() + "','" + p.getPrimerApellido() + "','" + p.getSegundoApellido() + "','" + p.getFechaNacimiento() + "','" + p.getDireccion() + "','" + p.getTelefono() + "','" + p.getOcupacion() + "','" + p.getCorreo() + "','" + p.getGenero() + "')";
        try {
            stm.execute(query);
            exitos = true;
        } catch (Exception e) {
            e.printStackTrace(System.err);
        } finally {
            desconectar();
        }
        return exitos;
    }

    public int buscarPaciente(int cedula) throws SQLException {
        conectar();
        int pac;
        PreparedStatement stt = conn.prepareStatement("select count(*) as cant from paciente "
                + "where idPaciente = ?");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
        rs = stt.executeQuery();
        rs.next();

        pac = rs.getInt(1);
        desconectar();
        return pac;

    }

    //Obtener los datos de un paciente
    public Paciente obtenerPaciente(int cedula) throws SQLException, IOException, ClassNotFoundException {
        conectar();
        Paciente pac = null;

        PreparedStatement stt = conn.prepareStatement("SELECT * FROM paciente "
                + "WHERE idPaciente= ?");

        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
        rs = stt.executeQuery();
        rs.next();
        if (rs.getBlob(10) != null) {
            pac = new Paciente(rs.getInt(1), rs.getString(2),
                    rs.getString(3), rs.getString(4),
                    rs.getString(5), rs.getString(6),
                    rs.getString(7), rs.getString(8),
                    rs.getString(9), rs.getString(10),
                    abrirImagen(rs.getBlob(10)), rs.getString(11));
        } else {
            pac = new Paciente(rs.getInt(1), rs.getString(2),
                    rs.getString(3), rs.getString(4),
                    rs.getString(5), rs.getString(6),
                    rs.getString(7), rs.getString(8),
                    rs.getString(9), rs.getString(10),
                    null, rs.getString(11));
        }
        desconectar(); //Necesito desconectar esta consulta
        return pac;

    }

    //Obtener la edad actual del paciente 
    public int obtenerEdadPac(int cedula) throws SQLException {
        conectar();
        int edad;

        PreparedStatement stt = conn.prepareStatement("SELECT TIMESTAMPDIFF(YEAR,fechaNacimiento,CURRENT_DATE) as edad from paciente "
                + "WHERE idPaciente= ?");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
        rs = stt.executeQuery();
        rs.next();

        edad = rs.getInt(1);
        desconectar();

        return edad;

    }
    //Actualizar datos de un paciente

    public boolean actualizarPaciente(int id_Paciente, String dato, String nuevoDato) {
        conectar();
        boolean actualizado = false;
        try {
            stm.execute("UPDATE PACIENTE SET " + dato + "='" + nuevoDato + "' WHERE idPaciente=" + id_Paciente);
            actualizado = !actualizado;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return actualizado;
    }

    //Actualizar foto de un paciente
    public boolean actualizarFotoPac(int id_Paciente, String mimeFoto) {
        int registros;
        boolean actualizado = false;
        try {
            conectar();
            PreparedStatement stt = conn.prepareStatement("UPDATE PACIENTE SET foto=?, mimeFoto=? WHERE idPaciente=?");
            stt.clearParameters();
            actualizado = !actualizado;
            stt.setBlob(1, this.getDirectorio_1());
            stt.setString(2, mimeFoto);
            stt.setInt(3, id_Paciente);
            registros = stt.executeUpdate();
            actualizado = registros == 1;
            stt.close();
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return actualizado;
    }

    //Saber si paciente tiene imagen
    public boolean obtenerFoto(int cedula) throws SQLException, IOException, ClassNotFoundException {
        conectar();

        boolean tieneFoto = false;

        PreparedStatement stt = conn.prepareStatement("SELECT foto FROM paciente "
                + "WHERE idPaciente= ?");

        stt.clearParameters();
        stt.setInt(1, cedula);  // idPaciente : int
        rs = stt.executeQuery();
        rs.next();
        if (rs.getBlob(1) != null) {
            tieneFoto = true;
        }
        desconectar(); //Necesito desconectar esta consulta
        return tieneFoto;

    }
    //Abrir la imagen de un paciente desde la base de datos

    public Image abrirImagen(Blob imagen) throws SQLException, IOException, ClassNotFoundException {
        Image rpta;
        rpta = javax.imageio.ImageIO.read(imagen.getBinaryStream());

        return rpta;
    }

    //Cargar la foto de un paciente desde la base a la página web
    public void cargarFoto(HttpServletResponse response, int idP) {
        conectar();
        try {
            ImageIcon img = new ImageIcon("img/foto.png");

            String query = "select foto, mimeFoto from paciente where idPaciente = " + idP;
            rs = stm.executeQuery(query);
            if (rs.next()) {
                String mimeP = rs.getString("mimeFoto");

                response.reset();
                response.setContentType(mimeP);

                byte[] buffer = new byte[10000000];

                InputStream is = rs.getBinaryStream("foto");
                OutputStream fos2 = response.getOutputStream();
                if (is.read(buffer) > 0) {
                    fos2.write(buffer);
                }

                is.close();
                fos2.close();
                fos2.flush();
            }

        } catch (Exception e) {
            e.printStackTrace(System.err);
        } finally {
            desconectar();
        }

    }

    public Blob getDirectorio_1() {
        return Directorio_1;
    }

    public void setDirectorio_1(Blob b1) {
        Directorio_1 = b1;
    }

    public FileInputStream getFile() {
        return file;
    }

    public void setFile(FileInputStream b1) {
        file = b1;
    }

    public File getFile0() {
        return fi;
    }

    public void setFile0(File b1) {
        fi = b1;
    }

    public boolean insertarExamen_Fisico(Examen_Fisico EF) {

        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Examen_Fisico(identificacionPaciente_EF,FrecuenciaCardiaco,FrecuenciaRespiratoria,"
                    + "Pulso,Temperatura,Estatura,Peso,Cabeza,Cuello,Torax,Abdomen, Extremidades, fechaCreacionA_EF)"
                    + "VALUES (" + EF.getIdentificacionPaciente_EF() + ",'" + EF.getFrecuenciaCardiaco()
                    + "','" + EF.getFrecuenciaRespiratoria() + "','" + EF.getPulso() + "','" + EF.getTemperatura()
                    + "','" + EF.getEstatura() + "','" + EF.getPeso() + "','" + EF.getCabeza() + "','" + EF.getCuello()
                    + "','" + EF.getTorax() + "','" + EF.getAbdomen() + "','" + EF.getExtremidades() + "','" + patron.format(new Date()) + "')");
            this.insertarFichaClinica(EF.getIdentificacionPaciente_EF());
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarAntecedente_QT(Antecedente_QT QT) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Antecedente_QT(identificacionPaciente_QT, descripcion,fechaCreacionA_QT)"
                    + "VALUES (" + QT.getIdentificacionPaciente_QT()  + ",'" + QT.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarPadecimiento_Actual(Padecimiento_Actual PA) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Padecimiento_Actual(identificacionPaciente_PadecimientoActual,descripcion, fechaCreacion_PA)"
                    + "VALUES (" + PA.getIdentificacionPaciente_PadecimientoActual()+ ",'" + PA.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarAntecedente_Personal_Patalogicos(Antecedente_Personal_Patalogicos APP) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Antecedente_Personal_Patalogicos(identificacionPaciente_AP_Patologicos,descripcion,fechaCreacionA_PP)"
                    + "VALUES (" + APP.getIdentificacionPaciente_AP_Patologicos() + ",'" + APP.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarAntecedente_Personal_NOPatalogicos(Antecedente_Personal_NOPatalogicos APnP) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Antecedente_Personal_NOPatalogicos(identificacionPaciente_AP_NoPatologicos,descripcion,fechaCreacionA_PNP)"
                    + "VALUES (" + APnP.getIdentificacionPaciente_AP_NoPatologicos() + ",'" + APnP.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarAntecedentesGerico_obstetricos(AntecedentesGerico_obstetricos gericoAbs) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO AntecedentesGerico_obstetricos(identificacionPaciente_Gerico_obstetricos,descripcion,fechaCreacionA_GA)"
                    + "VALUES (" + gericoAbs.getIdentificacionPaciente_Abstetrico() + ",'" + gericoAbs.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarHeredo_Familiares(Heredo_Familiares HF) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Heredo_Familiares(identificacionPaciente_HeredoFamiliares,descripcion, fechaCreacionA_HF)"
                    + "VALUES (" + HF.getIdentificacionPaciente_HeredoFamiliares() + ",'" + HF.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarFichaClinica(int id_paciente) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Ficha_Clinica(id_Paciente,id_Administrador,fechaCreacion)"
                    + "VALUES (" + id_paciente + "," + conexionBD.id_administrador + ",'" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarReceta(Receta recet) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Receta(identificacionPaciente_Receta,"
                    + "NombreMedicamento,cantidadConsumo,descripcionIndicacion,fechaReceta)"
                    + "VALUES (" + recet.getIdentificacionPaciente_Receta() + ",'" + recet.getNombreMedicamento()
                    + "'," + recet.getCantidadConsumo() + ",'" + recet.getDescripcionIndicacion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public boolean insertarRecomendacion(Recomendacion recom) {
        patron = new SimpleDateFormat("yyyy/MM/dd");
        conectar();
        try {
            stm.executeUpdate("INSERT INTO Recomendacion(identificacionPaciente_Recomendacion,descripcion,fechaCreacion_Recomendacion)"
                    + "VALUES (" + recom.getIdentificacionPaciente_Recomendacion() + ",'" + recom.getDescripcion() + "','" + patron.format(new Date()) + "')");
            return true;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return false;
    }

    public List<Receta> obtenerReceta(int cedula) throws SQLException {
        conectar();
        List<Receta> lista_medicamentos = new ArrayList();
        Receta receta;
        rs = stm.executeQuery("select * from Receta "
                + "where identificacionPaciente_Receta =" + cedula + ";");
        while (rs.next()) {
            receta = new Receta(rs.getString(3), rs.getString(4), rs.getString(5));
            lista_medicamentos.add(receta);
//          System.out.println(":-P" + rs.getString(3)+ rs.getString(4)+ rs.getString(5));
        }
        return lista_medicamentos;
    }

    public List<Recomendacion> obtenerRecomendaciones(int cedula) throws SQLException {
        conectar();
        List<Recomendacion> lista_recomendaciones = new ArrayList();
        Recomendacion recomendacion;
        rs = stm.executeQuery("select * from Recomendacion "
                + "where identificacionPaciente_Recomendacion =" + cedula + ";");
        while (rs.next()) {
            recomendacion = new Recomendacion(rs.getString(3));
            lista_recomendaciones.add(recomendacion);
            // System.out.println(":-P" + rs.getString(3));
        }
        return lista_recomendaciones;
    }

    public List datosExamenFisico(int cedulaIdentidad) throws SQLException {
        conectar();
        List lista_datos = new ArrayList();
        ResultSet rs = stm.executeQuery("SELECT * FROM Examen_Fisico WHERE identificacionPaciente_EF = " + cedulaIdentidad);
        while (rs.next()) {
            Examen_Fisico Ef = new Examen_Fisico();
            Ef.setFrecuenciaCardiaco(rs.getString(3));
            Ef.setFrecuenciaRespiratoria(rs.getString(4));
            Ef.setPulso(rs.getString(5));
            Ef.setTemperatura(rs.getString(6));
            Ef.setEstatura(rs.getString(7));
            Ef.setPeso(rs.getString(8));
            Ef.setCabeza(rs.getString(9));
            Ef.setCuello(rs.getString(10));
            Ef.setTorax(rs.getString(11));
            Ef.setAbdomen(rs.getString(12));
            Ef.setExtremidades(rs.getString(13));
            Ef.setFechaCreacion(rs.getString(14));
            System.out.println("Lista FrecuenciaCardiaco => "
                    + Ef.getFrecuenciaCardiaco() + " FrecuenciaRespiratoria: "
                    + Ef.getFrecuenciaRespiratoria() + " Pulso: "
                    + Ef.getPulso() + " Temperatura: "
                    + Ef.getTemperatura() + " Estatura: "
                    + Ef.getEstatura() + " Peso: "
                    + Ef.getPeso() + " Cabeza : "
                    + Ef.getCabeza() + " Cuello: "
                    + Ef.getCuello() + " Torax: "
                    + Ef.getTorax() + " Abdomen: "
                    + Ef.getAbdomen() + " Extremidades: "
                    + Ef.getExtremidades() + " Fecha de creacion: "
                    + Ef.getFechaCreacion());
            lista_datos.add(Ef);
        }
        desconectar();
        return lista_datos;
    }

    public List DatosPaciente() throws SQLException {
        conectar();
        List pacientList = new ArrayList();
        // obtain list of titles
        ResultSet results = stm.executeQuery(
                "SELECT idPaciente,nombre,primerApellido, segundoApellido,fechaNacimiento FROM Paciente");

        while (results.next()) {
            Paciente pacien = new Paciente();
            pacien.setId_Paciente(results.getInt(1));
            pacien.setNombre(results.getString(2));
            pacien.setPrimerApellido(results.getString(3));
            pacien.setSegundoApellido(results.getString(4));
            pacien.setFechaNacimiento(results.getString(5));
            pacientList.add(pacien);
        }
        desconectar();
        return pacientList;
    }

    public int CountPaciente() throws SQLException {
        conectar();
        int numero = -1;
        ResultSet rs = stm.executeQuery("SELECT COUNT(*)"
                + "FROM PACIENTE");
        rs.next();
        numero = rs.getInt(1);
        rs.close();

        desconectar();
        return numero;
    }
    
    public Administrador obtenerAdministrador(int identificacion)throws SQLException {
        conectar();
        Administrador adm= null;
        // obtain list of titles
        ResultSet results = stm.executeQuery(
                "SELECT * FROM Administrador");

        while (results.next()) {
            adm = new Administrador(
            results.getInt(1),
            results.getString(2),
            results.getString(3),
            results.getString(4));
        }
        desconectar();
        return adm;
    }
         public boolean actualizarAdministrador(int id_Administrador, String dato, String nuevoDato) {
        conectar();
        boolean actualizado = false;
        try {
            stm.execute("UPDATE ADMINISTRADOR SET " + dato + "='" + nuevoDato + "' WHERE id_Administrador=" + id_Administrador);
            actualizado = !actualizado;
        } catch (SQLException ex) {
            Logger.getLogger(conexionBD.class.getName()).log(Level.SEVERE, null, ex);
        }
        desconectar();
        return actualizado;
    }
         
     public List DatosAdministrados() throws SQLException {
        conectar();
        List adminList = new ArrayList();
        ResultSet results = stm.executeQuery(
                "SELECT id_Administrador,nombre,correo,contrasenia FROM Administrador");

        while (results.next()) {
            Administrador adm = new Administrador();
            adm.setId_Administrador(results.getInt(1));
            adm.setNombre(results.getString(2));
            adm.setCorreo(results.getString(3));
            adm.setContrasenia(results.getString(4));
            adminList.add(adm);
        }
        desconectar();
        return adminList;
    } 
     
  public ArrayList<String> obtenerFechas(int cedula) throws SQLException {
        conectar();
        // Lista de fechas para crear vistas a los consecutivos
        ArrayList<String> fechas = new ArrayList<String>();
    
        String fecha;
        rs = stm.executeQuery("select fechaCreacion_PA from Padecimiento_Actual "
                + "where identificacionPaciente_PadecimientoActual =" + cedula + " ORDER BY fechaCreacion_PA DESC;");
        while (rs.next()) {
            fecha = rs.getString(1);
            fechas.add(fecha);
       
        }
        return this.limpiaLista(fechas);
    }
     public ArrayList<String> limpiaLista(ArrayList<String> array){
       //Creamos un objeto HashSet
        HashSet hs = new HashSet();
        //Lo cargamos con los valores del array, esto hace quite los repetidos
        hs.addAll(array);
        //Limpiamos el array
        array.clear();
        //Agregamos los valores sin repetir
        array.addAll(hs);
        return array;
    }
     
     
     public ArrayList<String> obtenerPA(int cedula,String fechaC) throws SQLException {
        conectar();
        ArrayList<String> listaPA = new ArrayList<String>();
        String pA="";
        PreparedStatement stt = conn.prepareStatement("select descripcion from Padecimiento_Actual "
                + "where identificacionPaciente_PadecimientoActual =? " + " and fechaCreacion_PA ='"+ fechaC+"' ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
        
        rs = stt.executeQuery();
         while (rs.next()) {
                 pA = rs.getString(1);
                 listaPA.add(pA);
         }
        desconectar();
          
        return listaPA;
    }
      public boolean obtenerA_QT(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        
        String pA="";
        PreparedStatement stt = conn.prepareStatement("Select descripcion from Antecedente_QT "
                + "where identificacionPaciente_QT = ? and fechaCreacionA_QT = '"+ fechaC+"' ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
    
        rs = stt.executeQuery();
   
            while(rs.next()){
                     if(rs.first()){ elementos = true;}
                     pA = rs.getString(1);
                     mListas.getListaAQT().add(pA);
                    
            }
        desconectar(); 
        return  elementos;
    }
     
     public boolean obtenerAnt_GA(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        String pA="";
        PreparedStatement stt = conn.prepareStatement("select descripcion from AntecedentesGerico_obstetricos "
                + "where identificacionPaciente_Gerico_obstetricos = ? and fechaCreacionA_GA = '"+ fechaC+"'  ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
     
        rs = stt.executeQuery();
        
        while (rs.next()) {
                if(rs.first()){ elementos = true;}
                 pA = rs.getString(1);
                 mListas.getListaAGA().add(pA);
                
         }

        desconectar(); 
        return  elementos;
    }
     public boolean obtenerAnt_PP(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos=false;
        String pA="";
        PreparedStatement stt = conn.prepareStatement("select descripcion from Antecedente_Personal_Patalogicos "
                + "where identificacionPaciente_AP_Patologicos = ? and fechaCreacionA_PP  = '"+ fechaC+"' ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
        rs = stt.executeQuery();
      
        while (rs.next()) {
                 if(rs.first()){ elementos = true;}
                 pA = rs.getString(1);
                 mListas.getListaAPP().add(pA);
         }

        desconectar(); 
        return elementos;
    }
     public boolean obtenerAP_NP(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        String pA="";
        PreparedStatement stt = conn.prepareStatement("Select descripcion from Antecedente_Personal_NOPatalogicos"
                + " where identificacionPaciente_AP_NoPatologicos = ? and fechaCreacionA_PNP = '"+ fechaC+"';");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int
     
        rs = stt.executeQuery();
        
        while (rs.next()) {
            if(rs.first()){ elementos = true;}
                 pA = rs.getString(1);
                 mListas.getListaAPNP().add(pA);
                
         }

        desconectar(); 
        return elementos;
    }
       public boolean obtenerHeredo_Familiares(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        String pA="";
        PreparedStatement stt = conn.prepareStatement("select descripcion from Heredo_Familiares "
                + "where identificacionPaciente_HeredoFamiliares = ? and fechaCreacionA_HF  ='"+ fechaC+"'  ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int

        rs = stt.executeQuery();
        while (rs.next()) {
              if(rs.first()){elementos = true;}
                 pA = rs.getString(1);
                 this.getmListas().getListaHF().add(pA);
         }

        desconectar(); 
        return  elementos;
    }

       
    public boolean obtenerReco(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        String pA="";
        PreparedStatement stt = conn.prepareStatement("select descripcion from Recomendacion "
                + "where identificacionPaciente_Recomendacion = ? and fechaCreacion_Recomendacion ='"+ fechaC+"'  ;");
        stt.clearParameters();
        stt.setInt(1, cedula);    // idPaciente : int

        rs = stt.executeQuery();
       
        while (rs.next()) {
             if(rs.first()){elementos = true;}
                 pA = rs.getString(1);
                 getmListas().getListaReco().add(pA);
         }

        desconectar(); 
        return  elementos;
    }

   public boolean obtenerRece(int cedula,String fechaC) throws SQLException {
        conectar();
        boolean elementos = false;
        Receta receta;
        rs = stm.executeQuery("select NombreMedicamento , cantidadConsumo, descripcionIndicacion from Receta "
                + "where identificacionPaciente_Receta =" + cedula + " and fechaReceta ='"+fechaC+"';");
        while (rs.next()) {
            if(rs.first()){elementos=true;}
            receta = new Receta(rs.getString(1), rs.getString(2), rs.getString(3));
            mListas.getListaRecetas().add(receta);
        }
        return elementos;
    }

        
    /**
     * @return the mListas
     */
    public Manager getmListas() {
        return mListas;
    }

    /**
     * @param mListas the mListas to set
     */
    public void setmListas(Manager mListas) {
        this.mListas = mListas;
    }

    /**
     * @return the listaAQT
     */
}
